package com.tensquare.article.service;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.tensquare.article.client.NoticeClient;
import com.tensquare.article.dao.ArticleDao;
import com.tensquare.article.pojo.Article;
import com.tensquare.article.pojo.Notice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import util.IdWorker;

import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
public class ArticleService {

    @Autowired
    private ArticleDao articleDao;

    @Autowired
    private NoticeClient noticeClient;

    @Autowired IdWorker idWorker;

    @Autowired
    private RedisTemplate redisTemplate;

    public List<Article> findAll() {
        return articleDao.selectList(null);
    }

    public Article findById(String articleId) {
        return articleDao.selectById(articleId);
    }

    public void save(Article article) {
        String userId = "3";
        article.setUserid(userId);
    //    使用分布式id生成器
        String id = idWorker.nextId() + "";
        article.setId(id);

    //    初始化数据
        article.setVisits(0); //浏览量
        article.setThumbup(0); //点赞数
        article.setComment(0); //评论数

    //    新增
        articleDao.insert(article);

    //    新增文章后，发消息给订阅者
    //    获取订阅者信息
        String authorKey = "article_author_" + article.getUserid();
        Set<String> set = redisTemplate.boundSetOps(authorKey).members();

        if (null != set && set.size() > 0){

        }
        //    获取订阅者信息，给订阅者创建消息通知
        Notice notice = null;
        for (String uid : set) {
        //    创建消息对象
            notice = new Notice();

            notice.setReceiverId(uid);
            notice.setOperatorId(userId);
            notice.setAction("publish");
            notice.setTargetType("article");
            notice.setTargetId(id);
        //    通知类型
            notice.setType("sys");

            noticeClient.save(notice);
        }

    }

    public void updateById(Article article) {
    //    根据主键id修改
        articleDao.updateById(article);
    //    根据条件修改
    //    创建条件对象
    //     EntityWrapper<Article> wrapper = new EntityWrapper<>();
    //     //设置条件
    //     wrapper.eq("id",article.getId());
    //     articleDao.update(article,wrapper);
    }

    public void deleteById(String articleId) {
        articleDao.deleteById(articleId);
    }

    public Page<Article> findByPage(Map<String, Object> map, Integer page, Integer size) {
    //    设置查询条件
        EntityWrapper<Article> wrapper = new EntityWrapper<>();
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            if (map.get(key) != null){
                wrapper.eq(key,map.get(key));
            }
            //第一个参数是否将后面的条件加入到查询条件中
            wrapper.eq(map.get(key) != null,key,map.get(key));
        }
    //    设置分页参数
        Page<Article> pageData = new Page<>(page, size);

    //    执行查询
    //    第一个是分页参数，第二个是查询条件
        List<Article> list = articleDao.selectPage(pageData, wrapper);

        pageData.setRecords(list);
    //  返回
        return pageData;
    }

    public Boolean subscribe(String articleId, String userId) {
    //    根据文章id查询作者id
        String authorid = articleDao.selectById(articleId).getUserid();

        //存放用户订阅信息的集合key，里边存放作者id
        String userKey = "article_subscribe_" + userId;
        //存放作者订阅信息的集合key，里边存放订阅者id
        String authorKey = "article_author_" + authorid;
        //    查询用户订阅关系，是否订阅该作者
        Set set = redisTemplate.boundSetOps(userKey).members();

        Boolean flag = redisTemplate.boundSetOps(userKey).isMember(authorid);
        if (flag == true){
            //    如果订阅就取消订阅
            //在用户订阅信息集合中删除作者
            redisTemplate.boundSetOps(userKey).remove(authorid);
            //作者订阅者信息的集合中，删除订阅者
            redisTemplate.boundSetOps(authorKey).remove(userId);
            //    返回false
            return false;
        }else{
            //    如果没有订阅,就进行订阅
            //在用户订阅信息中，添加作者
            redisTemplate.boundSetOps(userKey).add(authorid);
            //在作者订阅者信息中，添加用户
            redisTemplate.boundSetOps(authorKey).add(userId);
            //    返回true
            return true;
        }

    }

    //文章点赞
    public void thumpup(String articleId, String userId) {
        Article article = articleDao.selectById(articleId);
        article.setThumbup(article.getThumbup() + 1);
        articleDao.updateById(article);

        //点赞成功后，需要发送消息给文章作者（点对点消息）
        Notice notice = new Notice();
        // 接收消息用户的ID
        notice.setReceiverId(article.getUserid());
        // 进行操作用户的ID
        notice.setOperatorId(userId);
        // 操作类型（评论，点赞等）
        notice.setAction("publish");
        // 被操作的对象，例如文章，评论等
        notice.setTargetType("article");
        // 被操作对象的id，例如文章的id，评论的id'
        notice.setTargetId(articleId);
        // 通知类型
        notice.setType("user");

        //保存消息
        noticeClient.save(notice);

        // //1 创建Rabbit管理器
        // RabbitAdmin rabbitAdmin = new RabbitAdmin(rabbitTemplate.getConnectionFactory());
        //
        // //2 创建队列，每个作者都有自己的队列，通过作者id进行区分
        // Queue queue = new Queue("article_thumbup_" + article.getUserid(), true);
        // rabbitAdmin.declareQueue(queue);
        //
        // //3 发消息到队里中
        // rabbitTemplate.convertAndSend("article_thumbup_" + article.getUserid(), articleId);
    }
}
